/*******************************************************************************
/
/ tablero.h
/
/ Creado por Roberto García Carvajal.
/
/ Prepara el dibujo de las batallas. Incluye detección de colisiones y gestión
/ de unidades de forma acelerada.
/
/ El dibujo de los tableros está acelerado aunque tengo pendiente una mejora en
/ rendimiento durante el redibujo de zonas.
/
/ Documento bajo licencia GPL.
/
*******************************************************************************/

#include <SDL/SDL.h>
#include <map>
#include <vector>
#include "mapa.h"
#include "Personajes.h"

using namespace std;

struct coordenada;

#ifndef _C_TABLERO_
#define _C_TABLERO_

// Declaración adelantada.
class c_svideo;

// Objeto función que ordena por coordenadas.

struct ordenacoor
{
 bool operator()(pair<int,int>a,pair<int,int> b)
 {
  if(a.second < b.second)
   return true;
  if(a.second > b.second)
   return false;
  if(a.first < b.first)
   return true;
  return false;
 }
};

class c_tablero
{
 public:
  // Constructor.
  c_tablero();
  // Asocia el sistema de video.
  void asociar_svideo(c_svideo * v) { svideo = v; }
  // Devuelve el tablero actual.
  SDL_Surface * tablero();
  // Devuelve el minimapa actual.
  SDL_Surface * dminimapa();
  // Devuelve t_personajes.
  SDL_Surface * personajes() { return t_personajes; }
  // Devuelve el recorte actual de t_tablero.
  SDL_Rect recorte() { return t_rtablero; }
  // Asocia un mapa.
  void asociar_mapa(c_mapa mapa);
  // Mueve en una dirección.
  void moverse(int mov);
  // Habilita el modo edición.
  void hmodoedicion();
  // Deshabilita el modo edición.
  void dmodoedicion();
  // Dibuja una zona (en modo edición).
  void pintar(int posx, int posy);
  // Elige el pincel.
  void epincel(int x);
  // Devuelve el mapa actual.
  c_mapa mapa_actual() {return t_mapa;}
  // Carga datos del jugador local.
  void jugador_local(int ejer,vector<personaje> p,vector<coordenada> c);
  // Carga datos del jugador remoto.
  void jugador_remoto(int ejer,vector<personaje> p,vector<coordenada> c);
  // Procesa una colisión en una posición.
  void click(int posx,int posy);
  // Muestra un ataque remoto.
  void ataque_remoto(int idg,SDL_Surface * dano);
  // Muestra un movimiento remoto.
  void movimiento_remoto(int idg,int x, int y);
  // Borra una unidad local.
  void elimina_unidad_local(int idg);
  // Borra una unidad remota.
  void elimina_unidad_remota(int idg);
  // Restaura el movimiento de las unidades locales (para un nuevo turno).
  void restaurar_movimiento();
 private:
  c_svideo * svideo;
  // Regenera la porción de mapa visualizable.
  void regenerar();
  // Redibuja las costas.
  void recostear();
  // Devuelve lo que hay en dicha casilla.
  int observar_casilla(int i,int j);
  // Regenera el minimapa.
  void regenerar_minimapau();
  // recorte del tablero.
  SDL_Rect t_rtablero;
  // tablero.
  SDL_Surface * t_tablero;
  // tiles.
  SDL_Surface ** tile;
  // tiles costas.
  SDL_Surface *** tile_costas;
  // tiles esquinas.
  SDL_Surface *** tile_esquinas;
  // tiles del minimapa.
  SDL_Surface ** minitile;
  // fondo del minimapa.
  SDL_Surface * fondominimapa;
  // minimapa.
  SDL_Surface * minimapa;
  SDL_Surface * minimapaf;
  // Unidades del minimapa.
  SDL_Surface * minimapau;
  // Rejilla para el modo edición.
  SDL_Surface * rejilla;
  // Para los personajes.
  SDL_Surface * t_personajes;
  // Para unidades locales.
  SDL_Surface ** ud_locales;
  // Para unidades remotas.
  SDL_Surface ** ud_remotas;
  // Vectores para las texturas de los personajes.
  SDL_Surface ** up;
  SDL_Surface ** ui;
  // Matrices de mapa.
  int *** t_tablero_costas;
  int *** t_tablero_esquinas;
  unsigned int t_x,t_y;
  c_mapa t_mapa;
  unsigned int contador;
  unsigned int pincel;
  int FLAGS;
  int ejer_l,ejer_r;
  int **m_ud_l;
  int **m_ud_r;
  int contador_minimapa;
  
  // Para la gestión de unidades.
  map<int,pair<int,int> > culi;
  map<pair<int,int>,pair<int,int>,ordenacoor> culc;
  map<int,pair<int,int> > curi;
  map<pair<int,int>,pair<int,int>,ordenacoor> curc;
  map<int,int> movul;
  map<int,int> movul_backup;
  int **t_mapamov;
  pair<int,int> c_u_mov;
};

#endif
